#include "LanzadorPajaritos.h"

using namespace TP::Juego::Arena::Utilidades;

pajaro_t* LanzadorPajaritos::__generarPajaro() {
    int tmp;
    pajaro_t* nuevoPajarito;
    
    tmp = rand() % MAX_INTERVALO; 
    
    if(tmp <= this->_prob_pajaro_rojo) {
        nuevoPajarito = new PajaritoRojo();
    }
    else if (tmp > this->_prob_pajaro_rojo && tmp <= this->_prob_pajaro_azul) {
        nuevoPajarito = new PajaritoAzul();
    }
    else { 
        nuevoPajarito = new PajaritoVerde();
    }
    return nuevoPajarito;
    //throw "Lanzador de pajaritos. LanzadorDePajaros no implementado";
}

Posicion* LanzadorPajaritos::__generarPosicion() const {
    Posicion *nuevaPosicion; 
    pos_t posX, posY;
     
    _posicion.generarNumeros(posX, posY);
    nuevaPosicion = new Posicion(posX, posY);
    return nuevaPosicion;
}

Vector2D* LanzadorPajaritos::__generarVelocidad() const {
    Vector2D *nuevaVelocidad;
     speed_t speedX, speedY;
     
     _velocidad.generarNumeros(speedX, speedY);
     nuevaVelocidad = new Vector2D(speedX, speedY);
     return nuevaVelocidad;
}

Vector2D* LanzadorPajaritos::__generarAceleracion() const {
    Vector2D *nuevaAceleracion ;
    accel_t accelX, accelY;
     
     _aceleracion.generarNumeros(accelX, accelY);
     nuevaAceleracion = new Vector2D(accelX, accelY);
     return nuevaAceleracion;
}

void LanzadorPajaritos::__disparar() {
    int cantPajaros; // Cantidad de pájaros que se van a lanzar.
    pajaro_t* nuevoPajaro;
    Posicion *posicion;
    Vector2D *velocidad;
    Vector2D *aceleracion;
    
    // Cantidad de pájaros que va a tener el grupo a lanzar.
    cantPajaros = rand() % CANT_MAX_PAJAROS;  
    
    for(int i = 0; i < cantPajaros; ++i) {
        nuevoPajaro = __generarPajaro();
        posicion = __generarPosicion();
        velocidad = __generarVelocidad();
        aceleracion = __generarAceleracion();
        _partida.ArenaJuego()->addActor(nuevoPajaro, posicion, velocidad, aceleracion);
        //throw "lanzadorDePajaritos.disparar() no implementado";
    }
}

LanzadorPajaritos::LanzadorPajaritos(Partida& partida, struct InfoMov &infoMov) :
_posicion(infoMov._pXm, infoMov._pXM, infoMov._pYm, infoMov._pYM),
_velocidad(infoMov._vXm, infoMov._vXM, infoMov._vYm, infoMov._vYM),
_aceleracion(infoMov._aXm, infoMov._aXM, infoMov._aYm, infoMov._aYM),
_partida(partida), _timer(TIEMPO_LANZAMIENTO, ASCENDENTE)
{    
    _prob_pajaro_rojo = floor(MAX_INTERVALO*infoMov._prob_rojo) - 1;
    _prob_pajaro_azul = _prob_pajaro_rojo + floor(MAX_INTERVALO*infoMov._prob_rojo) - 1;
    _prob_pajaro_verde = MAX_INTERVALO;
    _comenzado = false;
    _lanzados = false;
    srand(time(NULL));  // Inicializo las semillas para hacer el RANDOM.
}

LanzadorPajaritos::~LanzadorPajaritos() {
}

bool LanzadorPajaritos::lanzados() {
    return _lanzados;
}

void LanzadorPajaritos::tarea() {
    _comenzado = true;
    _timer.prender();  // Prendo el timer.
    _timer.Iniciar();  // Lanzo el thread.
    while(!_timer.timeOut()) {}  // Espero hasta que el timer termine de contar
    __disparar();  // Disparo los pajaritos
    _lanzados = true;
    _timer.apagar();  // Apago el timer
}